/**
 * imageLoaderService.js - 处理 DICOM 图像加载的服务
 * 用于从 ViewerPage.vue 中分离图像加载逻辑
 */
import cornerstone from 'cornerstone-core';
import cornerstoneWADOImageLoader from 'cornerstone-wado-image-loader';
import orthancService from '@/services/orthancService';

// 存储已加载的图像，用于缓存
const loadedImagesCache = new Set();

/**
 * 配置WADO图像加载器
 * @param {string} authHeader - 认证头信息
 */
export function configureImageLoader(authHeader) {
  // 配置 WADO 图像加载器
  cornerstoneWADOImageLoader.configure({
    beforeSend: (xhr) => {
      // 添加认证信息
      if (authHeader) {
        xhr.setRequestHeader('Authorization', authHeader);
      }
    },
    useWebWorkers: true,
    decodeConfig: {
      convertFloatPixelDataToInt: false,
      use16Bits: true
    }
  });
  
  // 启用 web worker
  const config = {
    maxWebWorkers: navigator.hardwareConcurrency || 4,
    startWebWorkersOnDemand: true,
    webWorkerPath: '/cornerstoneWADOImageLoaderWebWorker.js',
    taskConfiguration: {
      decodeTask: {
        loadCodecsOnStartup: true,
        initializeCodecsOnStartup: true
      }
    }
  };
  
  cornerstoneWADOImageLoader.webWorkerManager.initialize(config);
}

/**
 * 加载单张图像
 * @param {string} instanceId - 实例ID
 * @returns {Promise<Object>} 加载的图像对象
 */
export async function loadImage(instanceId) {
  try {
    // 创建图像ID
    const imageId = `wadouri:/api/instances/${instanceId}/file`;
    
    // 加载并缓存图像
    const image = await cornerstone.loadAndCacheImage(imageId);
    
    // 将图像ID添加到缓存集合
    loadedImagesCache.add(imageId);
    
    return { 
      success: true, 
      image,
      imageId
    };
  } catch (error) {
    console.error('加载图像失败:', error);
    return {
      success: false,
      error: error.message || '图像加载失败',
      imageId: null
    };
  }
}

/**
 * 高性能图像预加载
 * @param {Array<string>} instanceIds - 实例ID数组
 * @param {Object} options - 预加载选项
 * @param {number} options.currentIndex - 当前图像索引
 * @param {Function} options.onProgress - 进度回调
 * @param {number} options.concurrentRequests - 并发请求数量
 * @returns {Promise<Set>} 已加载图像集合
 */
export function preloadImages(instanceIds, options = {}) {
  const { 
    currentIndex = 0, 
    onProgress = () => {}, 
    concurrentRequests = 6 
  } = options;
  
  return new Promise((resolve) => {
    // 如果无图像需要预加载，直接返回
    if (!instanceIds || instanceIds.length === 0) {
      resolve(new Set());
      return;
    }
    
    // 记录开始时间，用于性能跟踪
    const startTime = performance.now();
    
    // 创建图像ID数组
    const imageIds = instanceIds.map(id => `wadouri:/api/instances/${id}/file`);
    
    // 优先级排序 - 当前图像附近的优先加载
    const prioritizedIds = imageIds.map((id, index) => ({
      id,
      priority: Math.abs(index - currentIndex) // 距离当前图像的距离作为优先级
    }))
    .sort((a, b) => a.priority - b.priority) // 按优先级排序
    .map(item => item.id);
    
    // 创建加载队列
    let queue = [...prioritizedIds];
    let activeRequests = 0;
    let completed = 0;
    
    // 处理队列中的下一个图像
    const processNext = () => {
      // 检查是否所有图像已处理完成
      if (queue.length === 0 && activeRequests === 0) {
        const totalTime = performance.now() - startTime;
        console.log(`✅ 所有图像加载完成，总耗时: ${totalTime.toFixed(2)}ms，平均每张: ${(totalTime / imageIds.length).toFixed(2)}ms`);
        resolve(loadedImagesCache);
        return;
      }
      
      // 如果队列为空或已达到最大并发数，则返回
      if (queue.length === 0 || activeRequests >= concurrentRequests) {
        return;
      }
      
      // 从队列中取出下一个图像ID
      const imageId = queue.shift();
      
      // 如果图像已加载，则处理下一个
      if (loadedImagesCache.has(imageId)) {
        processNext();
        return;
      }
      
      // 增加活动请求计数
      activeRequests++;
      
      // 加载图像
      cornerstone.loadAndCacheImage(imageId)
        .then(() => {
          // 标记为已加载
          loadedImagesCache.add(imageId);
          completed++;
          
          // 调用进度回调
          onProgress(completed, imageIds.length);
          
          // 每加载10张图像打印一次进度
          if (completed % 10 === 0) {
            const percentage = Math.min(Math.round((completed / imageIds.length) * 100), 100);
            console.log(`已加载 ${completed}/${imageIds.length} 张图像 (${percentage}%)`);
          }
        })
        .catch(error => {
          console.error(`加载图像 ${imageId} 失败:`, error);
        })
        .finally(() => {
          // 减少活动请求计数
          activeRequests--;
          
          // 处理下一个图像
          processNext();
          
          // 同时启动更多的加载任务保持并发性
          for (let i = 0; i < Math.min(concurrentRequests - activeRequests, queue.length); i++) {
            processNext();
          }
        });
    };
    
    // 启动初始的并发加载
    for (let i = 0; i < Math.min(concurrentRequests, queue.length); i++) {
      processNext();
    }
  });
}

/**
 * 按照 DICOM 标签对实例进行排序
 * @param {Array} instances - 实例数组
 * @returns {Promise<Array>} 排序后的实例数组
 */
export async function sortInstances(instances) {
  try {
    if (!instances || instances.length === 0) {
      return [];
    }
    
    // 如果只有一个实例，无需排序
    if (instances.length === 1) {
      return instances;
    }
    
    // 收集标签数据
    const instancesWithPosition = [];
    
    for (const instance of instances) {
      try {
        const tags = await orthancService.getInstanceTags(instance);
        
        if (tags && tags.Tags) {
          // 尝试从多个可能的标签中获取位置信息
          let position = null;
          
          // 尝试 ImagePositionPatient 标签
          if (tags.Tags.ImagePositionPatient) {
            position = tags.Tags.ImagePositionPatient;
          }
          // 尝试 SliceLocation 标签
          else if (tags.Tags.SliceLocation) {
            position = tags.Tags.SliceLocation;
          }
          // 尝试 InstanceNumber 标签
          else if (tags.Tags.InstanceNumber) {
            position = tags.Tags.InstanceNumber;
          }
          
          // 处理位置字符串
          if (typeof position === 'string') {
            if (position.includes('\\')) {
              // 如果是 ImagePositionPatient 格式 (x\y\z)
              const parts = position.split('\\');
              // 使用 z 坐标排序
              position = parseFloat(parts[2] || 0);
            } else {
              // 单个数值的情况
              position = parseFloat(position);
            }
          }
          
          // 添加到数组供排序
          instancesWithPosition.push({
            instance,
            position: isNaN(position) ? 0 : position,
            instanceNumber: parseInt(tags.Tags.InstanceNumber || '0', 10)
          });
        } else {
          // 没有标签信息的情况
          instancesWithPosition.push({
            instance,
            position: 0,
            instanceNumber: 0
          });
        }
      } catch (error) {
        console.error(`获取实例 ${instance.ID} 标签失败:`, error);
        // 加入队列，但没有位置信息
        instancesWithPosition.push({
          instance,
          position: 0,
          instanceNumber: 0
        });
      }
    }
    
    // 排序逻辑: 优先按位置排序，如果位置相同则按实例编号排序
    instancesWithPosition.sort((a, b) => {
      // 首先按位置排序
      if (a.position !== b.position) {
        return a.position - b.position;
      }
      // 如果位置相同，按实例编号排序
      return a.instanceNumber - b.instanceNumber;
    });
    
    // 返回排序后的实例数组
    return instancesWithPosition.map(item => item.instance);
  } catch (error) {
    console.error('排序实例失败:', error);
    // 出错时返回原始顺序
    return instances;
  }
}

/**
 * 获取认证头信息
 * @returns {string} 认证头信息
 */
export function getAuthHeader() {
  const username = 'orthanc';
  const password = 'orthanc123';
  return 'Basic ' + btoa(`${username}:${password}`);
}

/**
 * 显示图像
 * @param {Element} element - 用于显示图像的DOM元素
 * @param {Object} image - cornerstone图像对象
 * @param {Object} options - 显示选项
 */
export function displayImage(element, image, options = {}) {
  try {
    cornerstone.displayImage(element, image, options);
    return true;
  } catch (error) {
    console.error('显示图像失败:', error);
    return false;
  }
}

export default {
  configureImageLoader,
  loadImage,
  preloadImages,
  sortInstances,
  getAuthHeader,
  displayImage
} 